package cn.caplike.demo.consistence.threadpool.and.blockingqueue.core;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 请求的队列<br>
 * 这里需要使用单例模式来确保请求的队列的对象只有一个
 *
 * @author LiKe
 * @version 1.0.0
 * @date 2020-03-18 13:52
 */
public class RequestQueueHolder {

    /**
     * 内存队列
     */
    private List<ArrayBlockingQueue<Request>> queueList = new ArrayList<>();
    /**
     * 标志位
     * 主要用来判断读请求去重的操作
     * Boolean true 表示更新数据的操作 false 表示读取缓存的操作
     */
    private Map<String, Boolean> tagMap = new ConcurrentHashMap<>(1);

    private RequestQueueHolder() {
    }

    /**
     * 获取 RequestQueue 对象
     */
    public static RequestQueueHolder getInstance() {
        return Singleton.getInstance();
    }

    /**
     * 向容器中添加队列
     */
    public void add(ArrayBlockingQueue<Request> queue) {
        this.queueList.add(queue);
    }

    /**
     * 获取指定的缓存队列
     */
    public ArrayBlockingQueue<Request> getQueue(int index) {
        return this.queueList.get(index);
    }

    /**
     * 获取队列大小
     */
    public int size() {
        return this.queueList.size();
    }

    /**
     * 返回标志位
     */
    public Map<String, Boolean> getTagMap() {
        return this.tagMap;
    }

    /**
     * 私有的静态内部类来实现线程安全的单例
     */
    private static class Singleton {
        private static RequestQueueHolder queue;

        static {
            queue = new RequestQueueHolder();
        }

        private static RequestQueueHolder getInstance() {
            return queue;
        }
    }
}
